home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / diskutil / gemar220.lzh / GEMAR220 / PLUGIN / SOURCE / INDEX.M next >
Encoding:
Text File  |  1994-02-12  |  10.9 KB  |  428 lines
  1. (*-------------------------------------------------------------------------*)
  2. (*-                                                                                                                                             -*)
  3. (*-     Name                        : Index                                                                                         -*)
  4. (*-     Version                 : 1.000                                                                                         -*)
  5. (*-     Art                         : Module                                                                                        -*)
  6. (*-     Aufgabe                 : PlugIn für GEMAR                                                                    -*)
  7. (*-     Autor                     : Steffen Engel                                             (C) 93                -*)
  8. (*-     Letzte Änderung : 27.10.1993, 12:35:52                                                            -*)
  9. (*-                                                                                                                                             -*)
  10. (*-------------------------------------------------------------------------*)
  11. (*-------------------------------------------------------------------------*)
  12. (*-                                                                                                                                             -*)
  13. (*- Beschreibung    : Bearbeiten des Index eines Backups.                                     -*)
  14. (*-                                 Nach einem Backup wird dieses PlugIn gerufen, um            -*)
  15. (*-                                 die Möglichkeit zu freiem Export des Index zu haben.    -*)
  16. (*-                                 Dabei wird Das Modul für jede Datei einmal aufge-         -*)
  17. (*-                                 rufen.                                                                                                -*)
  18. (*-                                 Als Beispiel gibt dieses Modul die Liste entweder in    -*)
  19. (*-                                 eine Datei aus, oder der Index wird ausgedruckt.            -*)
  20. (*-                                                                                                                                             -*)
  21. (*-------------------------------------------------------------------------*)
  22. (*-------------------------------------------------------------------------*)
  23. (*-                                                                                                                                             -*)
  24. (*-     History                                                                                                                         -*)
  25. (*-                                                                                                                                             -*)
  26. (*-                                                                                                                                             -*)
  27. (*-     Vers | Datum        | Beschreibung                                                                            -*)
  28. (*-  ------|----------|---------------------------------------                        -*)
  29. (*-     1.0  | 26.10.93 | erstellt                                                                                    -*)
  30. (*-              |                    |                                                                                                     -*)
  31. (*-                                                                                                                                             -*)
  32. (*-                                                                                                                                             -*)
  33. (*-                                                                                                                                             -*)
  34. (*-------------------------------------------------------------------------*)
  35. MODULE Index;
  36.  
  37. IMPORT SYSTEM, TOS, CPX;
  38.  
  39. IMPORT GEMDOS, Str, form, fsel;
  40.  
  41. (* Magic-Lib *)
  42. FROM MagicSys     IMPORT
  43.                                 (* Const *) Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5,
  44.                                                         Bit6, Bit7, Bit8, Bit9, Bit10, Bit11, Bit12,
  45.                                                         Bit13, Bit14, Bit15,
  46.                                 (* Type  *) LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL,
  47.                                                         sBITSET, lINTEGER, lCARDINAL, lWORD, lBITSET;
  48.  
  49.  
  50. IMPORT mtTime;
  51.  
  52.  
  53. IMPORT PlugParms;
  54.  
  55. CONST MaxPathLen = 513;                                  (* maximale Länge eines Pfades             *)
  56.             MaxNameLen = 128;                                  (* maximale Länge eines Dateinamens    *)
  57.  
  58. TYPE
  59.             Date                    = RECORD
  60.                                                 day  : SHORTCARD; (* [1..31]*)
  61.                                                 month: SHORTCARD; (* [1..12]*)
  62.                                                 year : SHORTINT;
  63.                                             END;
  64.  
  65.             Time                    = RECORD
  66.                                                 second: SHORTCARD; (*[0..59]*)
  67.                                                 minute: SHORTCARD; (*[0..59]*)
  68.                                                 hour    : SHORTCARD; (*[0..23]*)
  69.                                              END;
  70.  
  71.             FileAttr         = (readOnlyAttr,                     (* Datei nicht beschreibbar *)
  72.                                             hiddenAttr,                         (* Eintrag unsichtbar *)
  73.                                             systemAttr,                         (* (Unsichtbare) Systemdatei *)
  74.                                             volLabelAttr,                     (* Diskname *)
  75.                                             subdirAttr,                         (* Subdirectory *)
  76.                                             archiveAttr);                     (* Archivierte Datei *)
  77.  
  78.             FileAttrSet  = SET OF FileAttr;
  79.  
  80.             tPathStr            = ARRAY[0..MaxPathLen] OF CHAR;
  81.             tNameStr            = ARRAY[0..MaxNameLen] OF CHAR;
  82.  
  83.             (* Daten eines Directory-Eintrages *)
  84.             tDirEntry         = RECORD
  85.                                                 attr: FileAttrSet;
  86.                                                 time: Time;
  87.                                                 date: Date;
  88.                                                 size: LONGCARD;
  89.                                             END;
  90.  
  91.             tListEntry         = RECORD
  92.                                                 pName             : POINTER TO tNameStr;
  93.                                                 Entry             : tDirEntry;
  94.                                             END;
  95.  
  96.             tFileEntry         = RECORD
  97.                                                  Path              : tPathStr;
  98.                                                  pFile             : POINTER TO tListEntry;
  99.                                              END;
  100.  
  101.             tpFileEntry      = POINTER TO tFileEntry;
  102.  
  103.  
  104.          tIndexHeader = RECORD
  105.                                          Header             : ARRAY[0..19]OF CHAR;
  106.                                                                                             (* TextInfo über das Backup  *)
  107.                                          Revision         : sCARDINAL;
  108.                                          time                 : Time;
  109.                                          date                 : Date;
  110.                                                                                                 (* Zeitpunkt der Anfertigung *)
  111.                                          DataSize         : lCARDINAL;    (* Anzahl der Datenblöcke      *)
  112.                                          IndexSize        : lCARDINAL;    (* Anzahl der Bytes im Index *)
  113.                                          reserved0        : lCARDINAL;
  114.                                          FileAnz            : sCARDINAL;    (* Anzahl der Dateien              *)
  115.                                          Cartridges     : sCARDINAL;    (* Anzahl der Bänder                 *)
  116.                                          reserved         : ARRAY[0..8] OF sCARDINAL;
  117.                                          Packed             : BOOLEAN;        (* Gepacktes Archiv?                 *)
  118.                                          reserved5        : SYSTEM.BYTE;
  119.                                          PackId             : ARRAY[0..15] OF CHAR;
  120.                                          Comment            : ARRAY[0..33] OF CHAR;
  121.                                          MintDrives     : lBITSET;
  122.                                      END;
  123.  
  124.         tpIndexHeader = POINTER TO tIndexHeader;
  125.  
  126.  
  127. VAR PrintIt : BOOLEAN;
  128.         LastPath, ExpFile : tPathStr;
  129.         ExpName : tNameStr;
  130.         handle    : SHORTINT;
  131.         PathSize, PathFiles : LONGCARD;
  132.         PlugEnv : PlugParms.tpPlugEnvironment;
  133.         IndexHeader : tpIndexHeader;
  134.  
  135.     
  136.  
  137. PROCEDURE WriteGEMDOS(Str : ARRAY OF CHAR);
  138. VAR Chars : LONGINT;
  139.     BEGIN
  140.         Chars := LENGTH(Str);
  141.         Chars := GEMDOS.Fwrite(handle, Chars, SYSTEM.ADR(Str));
  142.     END WriteGEMDOS;
  143.     
  144.     
  145. PROCEDURE InterpretStr(InStr:ARRAY OF CHAR; VAR OutStr:ARRAY OF CHAR);
  146.  
  147.  
  148.     VAR
  149.  
  150.         i,j      : SHORTCARD;
  151.  
  152.         InLen  : SHORTCARD;
  153.  
  154.         OutLen : SHORTCARD;
  155.  
  156.  
  157.     PROCEDURE ValHex(Ch:CHAR) : SHORTCARD;
  158.  
  159.  
  160.         BEGIN
  161.  
  162.             Ch:=CAP(Ch);
  163.  
  164.             IF Ch>'9' THEN
  165.  
  166.                 RETURN ORD(Ch)-55;
  167.  
  168.             ELSE
  169.  
  170.                 RETURN ORD(Ch)-48;
  171.  
  172.             END;
  173.  
  174.         END ValHex;
  175.  
  176.     
  177.  
  178.     BEGIN
  179.  
  180.         i:=0;
  181.  
  182.         j:=0;
  183.  
  184.         InLen:=HIGH(InStr)+1;
  185.  
  186.         OutLen:=HIGH(OutStr)+1;
  187.  
  188.         WHILE (InStr[j]<>0C) AND (j<InLen) AND (i<OutLen) DO
  189.  
  190.             IF InStr[j]='/' THEN
  191.  
  192.                 CASE CAP(InStr[j+1]) OF
  193.  
  194.                     'C' : OutStr[i]:=015C  |
  195.  
  196.                     'L' : OutStr[i]:=012C  |
  197.  
  198.                     'E' : OutStr[i]:=033C  |
  199.  
  200.                     '/' : OutStr[i]:=057C  |
  201.  
  202.                     'N' : OutStr[i]:=015C;
  203.  
  204.                                 INC(i);
  205.  
  206.                                 OutStr[i]:=012C; |
  207.  
  208.                     '$' : OutStr[i]:=CHR(16*ValHex(InStr[j+2])+ValHex(InStr[j+3]));
  209.  
  210.                                 INC(j,2)                 |
  211.  
  212.                 END;
  213.  
  214.                 INC(i);
  215.  
  216.                 INC(j,2);
  217.  
  218.             ELSE
  219.  
  220.                 OutStr[i]:=InStr[j];
  221.  
  222.                 INC(i);
  223.  
  224.                 INC(j);
  225.  
  226.             END;
  227.  
  228.         END;
  229.  
  230.         OutStr[i]:=0C;
  231.  
  232.     END InterpretStr;
  233.     
  234.  
  235. PROCEDURE WriteStr(Str:ARRAY OF CHAR);
  236.  
  237.  
  238. VAR  StrBuf : ARRAY[0..100] OF CHAR;
  239.  
  240.  
  241.     BEGIN
  242.  
  243.         InterpretStr(Str, StrBuf);
  244.  
  245.         WriteGEMDOS(StrBuf);
  246.  
  247.     END WriteStr;
  248.     
  249.  
  250. PROCEDURE WriteLNum(Num:LONGCARD;Width:SHORTCARD);
  251.  
  252.  
  253.     VAR
  254.  
  255.         NumStr : ARRAY[0..10] OF CHAR;
  256.  
  257.         i          : SHORTCARD;
  258.  
  259.  
  260.     BEGIN
  261.  
  262.         IF Width>0 THEN
  263.  
  264.             FOR i:=Width-1 TO 0 BY -1 DO
  265.  
  266.                 IF (Num = 0) AND (i # Width-1)
  267.  
  268.                     THEN
  269.  
  270.                         NumStr[i]:=' ';
  271.  
  272.                     ELSE
  273.  
  274.                         NumStr[i]:=CHR(48+VAL(SHORTCARD,Num MOD 10));
  275.  
  276.                         Num := Num DIV 10;
  277.  
  278.                     END;
  279.  
  280.             END;
  281.  
  282.             NumStr[Width]:=0C;
  283.  
  284.             WriteGEMDOS(NumStr);
  285.  
  286.         END;
  287.  
  288.     END WriteLNum;
  289.  
  290.                     
  291. PROCEDURE WriteLHex(Hex:LONGCARD;Width:SHORTCARD);
  292.  
  293.  
  294.     VAR
  295.  
  296.         NumStr    : ARRAY[0..10] OF CHAR;
  297.  
  298.         Potenz    : LONGCARD;
  299.  
  300.         Number,
  301.  
  302.         i             : SHORTCARD;
  303.  
  304.  
  305.     BEGIN
  306.  
  307.         IF Width>0 THEN
  308.  
  309.             Potenz:=1;
  310.  
  311.             FOR i:=Width-1 TO 0 BY -1 DO
  312.  
  313.                 Number:=VAL(SHORTCARD, (Hex DIV Potenz) MOD 16);
  314.  
  315.                 IF Number>9 THEN
  316.  
  317.                     NumStr[i]:=CHR(55+Number);
  318.  
  319.                 ELSE
  320.  
  321.                     NumStr[i]:=CHR(48+Number);
  322.  
  323.                 END;
  324.  
  325.                 Potenz:=Potenz*16;
  326.  
  327.             END;
  328.  
  329.             NumStr[Width]:=0C;
  330.  
  331.             WriteGEMDOS(NumStr);
  332.  
  333.         END;
  334.  
  335.     END WriteLHex;
  336.  
  337.  
  338. PROCEDURE WriteNum(Num,Width:SHORTCARD);
  339.  
  340.  
  341.     BEGIN
  342.  
  343.         WriteLNum(VAL(LONGCARD, Num), Width);
  344.  
  345.     END WriteNum;
  346.  
  347.  
  348. PROCEDURE WriteHex(Hex,Width:SHORTCARD);
  349.  
  350.  
  351.     BEGIN
  352.  
  353.         WriteLHex(VAL(LONGCARD, Hex),Width);
  354.  
  355.     END WriteHex;
  356.  
  357.  
  358. (*$K+ $E+ *)
  359. PROCEDURE CallPlug(File : tpFileEntry) : LONGINT;
  360.  
  361. VAR SwapStr : ARRAY[0..40] OF CHAR;
  362.  
  363.  
  364.     BEGIN
  365.  
  366.  
  367.         IF File = SYSTEM.ADDRESS(-1)
  368.  
  369.             THEN
  370.  
  371.                 (* hier sollen wir uns deinstallieren *)
  372.  
  373.                 IF ~PrintIt
  374.  
  375.                     THEN
  376.  
  377.                         handle := GEMDOS.Fclose(handle);
  378.  
  379.                     END;
  380.  
  381.             ELSIF File = NIL
  382.  
  383.             THEN
  384.  
  385.                 (* IndexHeader in private *)
  386.  
  387.                 IF PlugEnv^.Private # NIL
  388.  
  389.                     THEN
  390.  
  391.                         IndexHeader := PlugEnv^.Private;
  392.  
  393.                         WITH IndexHeader^ DO
  394.  
  395.                             WriteStr('/n************************************************'
  396.  
  397.                                              + '************************************************/n');
  398.  
  399.                 
  400.  
  401.                             WriteStr('Gemar-Index  ');
  402.  
  403.                 
  404.  
  405.                             WITH date DO
  406.  
  407.                                 mtTime.DateString(mtTime.EncodeDate(day, month, year),
  408.  
  409.                                                                     SwapStr);
  410.  
  411.  
  412.                             END;
  413.  
  414.                             WriteStr(SwapStr);
  415.  
  416.                             WriteStr('   ');
  417.  
  418.                             WITH time DO
  419.  
  420.                                 mtTime.TimeString(mtTime.EncodeTime(hour, minute, second),
  421.  
  422.                                                                     SwapStr);
  423.  
  424.                             END;
  425.  
  426.                             WriteStr(SwapStr);
  427.  
  428.                             WriteStr('/n');
  429.  
  430.                 
  431.  
  432.                 
  433.  
  434.                             IF LENGTH(Comment) # 0
  435.  
  436.                                 THEN
  437.  
  438.                                     WriteStr('>>> ');
  439.  
  440.                                     WriteStr(Comment);
  441.  
  442.                                     WriteStr('/n');
  443.  
  444.                                 END;
  445.  
  446.                             WriteStr('/n');
  447.  
  448.                 
  449.  
  450.                             WriteNum(FileAnz, 10);
  451.  
  452.                             WriteStr(' Entries/n');
  453.  
  454.                 
  455.  
  456.                             WriteLNum(DataSize, 10);
  457.  
  458.                             WriteStr(' Blocks/n');
  459.  
  460.                 
  461.  
  462.                             WriteNum(Cartridges, 10);
  463.  
  464.                             WriteStr(' Cartridge');
  465.  
  466.                             IF Cartridges > 1
  467.  
  468.                                 THEN
  469.  
  470.                                     WriteStr('s');
  471.  
  472.                                 END;
  473.  
  474.                             WriteStr('/n');
  475.  
  476.                 
  477.  
  478.                             IF Packed
  479.  
  480.                                 THEN
  481.  
  482.                                     WriteStr('Compressed by ');
  483.  
  484.                                     WriteStr(PackId);
  485.  
  486.                                 END;
  487.  
  488.  
  489.                             WriteStr('/n/n');
  490.  
  491.  
  492.                         END;
  493.  
  494.                     END;
  495.  
  496.             ELSE
  497.  
  498.                 IF ~Str.Equal(File^.Path, LastPath)
  499.  
  500.                     THEN
  501.  
  502.                         Str.Assign(LastPath, File^.Path);
  503.  
  504.                         WriteStr('/n====');
  505.  
  506.                         WriteLNum(PathFiles, 6);
  507.  
  508.                         WriteStr(' Files mit ');
  509.  
  510.                         WriteLNum(PathSize, 8);
  511.  
  512.                         WriteStr(' Bytes ====/n/n');
  513.  
  514.                         WriteStr('Ordner ');
  515.  
  516.                         WriteStr(LastPath);
  517.  
  518.                         WriteStr('/n/n');
  519.  
  520.                         PathSize := 0;
  521.  
  522.                         PathFiles := 0;
  523.  
  524.                     END;
  525.  
  526.  
  527.                 (* Ordner zählen *)
  528.  
  529.                 INC(PathFiles);
  530.  
  531.                 PathSize := PathSize + File^.pFile^.Entry.size;
  532.  
  533.  
  534.                 WriteStr('  ');
  535.  
  536.                 WriteStr(File^.pFile^.pName^);
  537.  
  538.                 IF LENGTH(File^.pFile^.pName^) < 20
  539.  
  540.                     THEN
  541.  
  542.                         SwapStr := '                    ';
  543.  
  544.                         SwapStr[20 - LENGTH(File^.pFile^.pName^)] := 0C;
  545.  
  546.                     ELSE
  547.  
  548.                         SwapStr := '  ';
  549.  
  550.                     END;
  551.  
  552.                 WriteStr(SwapStr);
  553.  
  554.                 WriteLNum(File^.pFile^.Entry.size, 8);
  555.  
  556.                 WriteStr('/n');
  557.  
  558.             END;
  559.  
  560.  
  561.         RETURN 0;
  562.  
  563.     END CallPlug;
  564. (*$K= $E+ *)
  565.  
  566.  
  567.  
  568.  
  569. PROCEDURE CutPath(VAR path : STRING);
  570.  
  571. VAR count, pos : LONGINT;
  572.  
  573.  
  574.     BEGIN
  575.  
  576.         FOR count := 0 TO LENGTH(ExpFile) DO
  577.  
  578.             IF ExpFile[count] = '\'
  579.  
  580.                 THEN
  581.  
  582.                     pos := count;
  583.  
  584.                 END;
  585.  
  586.         END;
  587.  
  588.         ExpFile[pos+1] := 0C;                     (* abschneiden *)
  589.  
  590.     END CutPath;
  591.  
  592.  
  593. BEGIN
  594.  
  595.  
  596.     PlugEnv := PlugParms.tpPlugEnvironment(CPX.pXCPB);
  597.  
  598.  
  599.     CASE PlugEnv^.Alert(3, '[1][PlugIn:|Index bearbeiten][[Drucken|Da[tei|:Abbruch]') OF
  600.  
  601.         1: PrintIt := TRUE;
  602.  
  603.              handle := 3;
  604.  
  605.  
  606.      |2: PrintIt := FALSE;
  607.  
  608.              Str.Assign(ExpFile, PlugEnv^.PlugPath^);
  609.  
  610.              CutPath(ExpFile);
  611.  
  612.              Str.Concat(ExpFile, '*.ASC');
  613.  
  614.              ExpName := '*.ASC';
  615.  
  616.              IF fsel.exinput(ExpFile, ExpName, 'Index exportieren')
  617.  
  618.                  THEN
  619.  
  620.                      CutPath(ExpFile);
  621.  
  622.                      Str.Concat(ExpFile, ExpName);     (* Namen dran *)
  623.  
  624.                      handle := GEMDOS.Fcreate(ExpFile, BITSET{});
  625.  
  626.                      IF handle < 0
  627.  
  628.                          THEN
  629.  
  630.                              CPX.Return(NIL);  (* Abbruch *)
  631.  
  632.                          END;
  633.  
  634.                  ELSE
  635.  
  636.                      (* Abbruch *)
  637.  
  638.                      CPX.Return(NIL);
  639.  
  640.                  END;
  641.  
  642.      ELSE CPX.Return(NIL);
  643.  
  644.     END;
  645.  
  646.  
  647.     LastPath := '';
  648.  
  649.     PathSize := 0;
  650.  
  651.     PathFiles := 0;
  652.  
  653.  
  654.     CPX.Return(SYSTEM.ADDRESS(CallPlug));
  655. END Index.
  656.         
  657.     
  658.